﻿using System;
using System.IO;
using System.IO.Ports;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Drawing;

namespace WindowsFormsApplication1
{
    class EcgRF
    {
        private FormPrincipal form;
        private double ganhoRF;
        private int escalaTempoRF;
        private int tempo;
        private int deslocamentoRF;
        private PictureBox[] pictureBoxRF = new PictureBox[4];
        private int[,] amostrasRF = new int[3, 864000]; //15*60*960 = 864000 = 15 minutos de gravação
        private int[,] amostrasAceleracaoRF = new int[3, 864000];
        private byte[] amostra = new byte[3 * 2 * 864000];//Variável que será salvada 
        private delegate void PassaDados(int i);
        private int semaforo; //Variável usada na Thread
        private int selectedPictureBox;
        private int selectedPictureBoxReplote;
        public double xAtual, xAnterior, yCanal1Anterior;
        public double yCanal1Atual, yCanal2Atual, yCanal3Atual, yCanal2Anterior, yCanal3Anterior;
        public double xAtualReplote, xAnteriorReplote, yCanal1AnteriorReplote;
        public double yCanal1AtualReplote, yCanal2AtualReplote, yCanal3AtualReplote, yCanal2AnteriorReplote, yCanal3AnteriorReplote;
        private byte[] vetor = new byte[26];
        public PictureBox pctboxSelected;
        public PictureBox pctboxSelectedReplote;
        public int posicaoPictureBoxAmostras;
        private int[] amostrasDetalhada = new int[9 * 960]; //Armazena no máximo 9s de dados
        private int tamanhoDetalhe = 9 * 960;
        private int derivacaoSelecionada;
        private int posicaoSelecionada;
        private int contaAmostra;
        private int contaAmostraImpressa;
        
        //Variávei para manipular arquivos
        private SaveFileDialog dlg;
        private FileStream output;
        private BinaryWriter br;
        private Boolean estourou15minutos = false;

        public int getPosicaoSelecionada()
        {
            return posicaoSelecionada;
        }

        public int[] getAmostrasDetalhada()
        {
            return amostrasDetalhada;
        }

        public void setForm(FormPrincipal form)
        {
            this.form = form;
        }

        public void inicializarTab()
        {
            form.timer.Enabled = false;
            form.SP = new SerialPort();
            form.SP.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
            foreach (string str in SerialPort.GetPortNames())
            {
                form.cbPorta.Items.Add(str);
            }
            //form.cbPorta.SelectedIndex = 0;

            //Seta valores iniciais
            semaforo = 0;
            contaAmostraImpressa = 0;
            tempo = 0;
            contaAmostra = 0;
            selectedPictureBox = 0;
            posicaoPictureBoxAmostras = 0;

            ganhoRF = 1; //Seta Ganho Inicial para 1
            deslocamentoRF = 0; 
            escalaTempoRF = 2 * 3840; //Seta escala de tempo para 25 mm/s
            
            //Inicaliza vetor de picture box usado na tela de RF
            pictureBoxRF[0] = form.pctbxRF1;
            pictureBoxRF[1] = form.pctbxRF2;
            pictureBoxRF[2] = form.pctbxRF3;
            pictureBoxRF[3] = form.pctbxRF4;

        }

        public void plotaGradeRF()
        {
            //RGB(250, 200, 100) eh a cor mais parecida com aqueles papeis milimetrados
            Color corLinha = Color.FromArgb(255, 250, 200, 100);
            for (int i = 0; i < 4; i++)
            {
                pictureBoxRF[i].Image = desenhaGrade(pictureBoxRF[i].Width, pictureBoxRF[i].Height, corLinha);
            }
        }

        private Bitmap desenhaGrade(int comprimento, int altura, Color cor)
        {
            int passoAltura = altura / 30;
            int passoComprimento = 960;

            // Estou Criando um Objeto do tipo BITMAP - Uma Imagem
            Bitmap objBMP;

            // Criando Objeto do Tipo Imagem
            Graphics objGrafico;

            // Determinando qual sera a altura/largura da imagem BMP; estou criando uma area que ocupa a tela inteira
            objBMP = new Bitmap(comprimento, altura);

            // Adicionando a Imagem BMP ao objeto grafico, que sera usado para mostrar a imagem
            objGrafico = Graphics.FromImage(objBMP);

            // Determinando a cor de fundo da imagem
            //Color representa ARGB (Alpha, Red, Green, Blue) o melhor e deixar como White
            objGrafico.Clear(Color.White);

            // Criando objeto usado para desenhar linhas e curvas
            Pen p = new Pen(cor, 0);

            //desenha as linhas da grade
            for (int i = 1; i <= altura / passoAltura; i++)
            {
                objGrafico.DrawLine(p, 0, i * passoAltura, comprimento, i * passoAltura);
            }

            //desenha as colunas
            for (int i = 1; i * passoComprimento <= escalaTempoRF; i++)
            {
                objGrafico.DrawLine(p, i * passoComprimento * comprimento / (escalaTempoRF), 0, i * passoComprimento * comprimento / (escalaTempoRF), altura);
            }
            return objBMP;
        }

        //Reseta todos os picture boxes e a captura de dados
        public void resetaPictureBoxes()
        {
            plotaGradeRF();
            selectedPictureBox = 0;
            posicaoPictureBoxAmostras = 0;
            contaAmostraImpressa = 0;
            tempo = 0;
            contaAmostra = 0;
            semaforo = 0;
            xAnterior = xAtual = 0;
            yCanal1Atual = yCanal2Atual = yCanal3Atual = yCanal1Anterior = yCanal2Anterior = yCanal3Anterior = 0;
        }

        public void iniciaCaptura()
        {
            if (form.btIniciaCaptura.Text == "Inicia Nova Captura") //Inicia Captura de Dados
            {
                form.btIniciaCaptura.Text = "Finalizar Captura";
                form.btnSalvarArquivo.Enabled = false;
                resetaPictureBoxes();

                // verificar se a porta está fechada
                if (!form.SP.IsOpen)
                {
                    try
                    {
                        // Inicializar os atributos da Classe Serial Port
                        form.btnInterromperCaptura.Enabled = true;
                        form.SP.PortName = form.cbPorta.Text;
                        form.SP.BaudRate = 115200;
                        form.SP.DataBits = 8;
                        form.SP.Parity = Parity.None;
                        form.SP.StopBits = StopBits.One;
                        form.SP.ReadTimeout = 1000;
                        form.SP.ReceivedBytesThreshold = 26; //Seta parametro para receber 26 bytes por vez
                        form.SP.Open();              //Abrir a Porta 
                        form.timer.Enabled = true;   // Acionar o posicaoPictureBoxador de Tempo
                        form.SP.DiscardInBuffer();
                    }
                    catch
                    {
                        MessageBox.Show("Status da Porta: " + form.cbPorta.Text + " inválida");
                    }
                    form.cbPorta.Enabled = false;
                }
            }
            else //Finaliza Captura de Dados
            {
                form.btIniciaCaptura.Text = "Inicia Nova Captura";
                form.btnSalvarArquivo.Enabled = true;
                form.cbPorta.Enabled = true;
                form.SP.Close();
                form.timer.Enabled = false;
                form.btnInterromperCaptura.Enabled = false;
                form.btnInterromperCaptura.Text = "Interromper Captura";
            }
        }

        public void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            int aceleracaoX, aceleracaoY, aceleracaoZ;
            int nib1, nib2, nib3;
            try
            {
                form.SP.Read(vetor, 0, 26);              // lê 27 bytes de SP1

                if ((vetor[24] == 0) && (vetor[25] == 0) && vetor != null)    // 00 no final ?
                {
                    //Se estorou 15 min sobrepõe dados
                    if (contaAmostra > 863999)
                    {
                        contaAmostra = 0;
                        //Flag para verifica se estourou 15 min
                        estourou15minutos = true;
                    }

                    for (int i = 0; i < 24; i++) {
                        amostra[6*contaAmostra + i] = vetor[i];
                    }
                    
                    nib1 = vetor[1] / 16;            //os 3 primeiros nibles de 4 bits são do eixo X
                    nib2 = vetor[3] / 16;            //primeiro pega os 4 bits mais sig.
                    nib3 = vetor[5] / 16;
                    aceleracaoX = nib3 * 256 + nib2 * 16 + nib1;

                    amostrasRF[0, contaAmostra] = (short)(vetor[0] + (short)((vetor[1] & 0x0f) * 256));
                    amostrasRF[1, contaAmostra] = (short)(vetor[2] + (short)((vetor[3] & 0x0f) * 256));
                    amostrasRF[2, contaAmostra] = (short)(vetor[4] + (short)((vetor[5] & 0x0f) * 256));

                    contaAmostra++;

                    //Se estorou 15 min sobrepõe dados
                    if (contaAmostra > 863999)
                    {
                        contaAmostra = 0;
                        //Flag para verifica se estourou 15 min
                        estourou15minutos = true;
                    }

                    nib1 = vetor[7] / 16;            //os 3 primeiros nibles de 4 bits são do eixo X
                    nib2 = vetor[9] / 16;            //primeiro pega os 4 bits mais sig.
                    nib3 = vetor[11] / 16;
                    aceleracaoY = nib3 * 256 + nib2 * 16 + nib1;

                    amostrasRF[0, contaAmostra] = (short)(vetor[6] + (short)((vetor[7] & 0x0f) * 256));
                    amostrasRF[1, contaAmostra] = (short)(vetor[8] + (short)((vetor[9] & 0x0f) * 256));
                    amostrasRF[2, contaAmostra] = (short)(vetor[10] + (short)((vetor[11] & 0x0f) * 256));

                    contaAmostra++;

                    //Se estorou 15 min sobrepõe dados
                    if (contaAmostra > 863999)
                    {
                        contaAmostra = 0;
                        //Flag para verifica se estourou 15 min
                        estourou15minutos = true;
                    }

                    nib1 = vetor[13] / 16;            //os 3 primeiros nibles de 4 bits são do eixo X
                    nib2 = vetor[15] / 16;            //primeiro pega os 4 bits mais sig.
                    nib3 = vetor[17] / 16;
                    aceleracaoZ = nib3 * 256 + nib2 * 16 + nib1;

                    amostrasRF[0, contaAmostra] = (short)(vetor[12] + (short)((vetor[13] & 0x0f) * 256));
                    amostrasRF[1, contaAmostra] = (short)(vetor[14] + (short)((vetor[15] & 0x0f) * 256));
                    amostrasRF[2, contaAmostra] = (short)(vetor[16] + (short)((vetor[17] & 0x0f) * 256));

                    contaAmostra++;

                    //Se estorou 15 min sobrepõe dados
                    if (contaAmostra > 863999)
                    {
                        contaAmostra = 0;
                        //Flag para verifica se estourou 15 min
                        estourou15minutos = true;
                    }

                    amostrasRF[0, contaAmostra] = (short)(vetor[18] + (short)((vetor[19] & 0x0f) * 256));
                    amostrasRF[1, contaAmostra] = (short)(vetor[20] + (short)((vetor[21] & 0x0f) * 256));
                    amostrasRF[2, contaAmostra] = (short)(vetor[22] + (short)((vetor[23] & 0x0f) * 256));
                    
                    //Armazena os valores da aceleração
                    amostrasAceleracaoRF[0, contaAmostra - 3] = aceleracaoX;
                    amostrasAceleracaoRF[0, contaAmostra - 2] = aceleracaoX;
                    amostrasAceleracaoRF[0, contaAmostra - 1] = aceleracaoX;
                    amostrasAceleracaoRF[0, contaAmostra] = aceleracaoX;
                    amostrasAceleracaoRF[1, contaAmostra - 3] = aceleracaoY;
                    amostrasAceleracaoRF[1, contaAmostra - 2] = aceleracaoY;
                    amostrasAceleracaoRF[1, contaAmostra - 1] = aceleracaoY;
                    amostrasAceleracaoRF[1, contaAmostra] = aceleracaoY;
                    amostrasAceleracaoRF[2, contaAmostra - 3] = aceleracaoZ;
                    amostrasAceleracaoRF[2, contaAmostra - 2] = aceleracaoZ;
                    amostrasAceleracaoRF[2, contaAmostra - 1] = aceleracaoZ;
                    amostrasAceleracaoRF[2, contaAmostra] = aceleracaoZ;

                    contaAmostra++;

                    Interlocked.Increment(ref semaforo);          // avisa pro Form
                }
                else
                {
                    // procurar o par 00 e ler (retirar do buffer) do início até o 00
                    for (int j = 0; j < 25; j++)
                        if ((vetor[j] == 0) && (vetor[j + 1] == 0))
                        {
                            form.SP.Read(vetor, 0, j + 2);
                            goto Aqui;
                        }
                    if ((vetor[0] == 0) && (vetor[25] == 0)) 
                        form.SP.Read(vetor, 0, 26);

                    Aqui: ;
                }

                //Adiciona uma thread
                form.BeginInvoke(new PassaDados(si_DataReceived), semaforo);
            }
            catch (Exception exceptiom)
            {
                MessageBox.Show("Deu erro no Recebimento dos dados da porta: " + exceptiom);
            }
        }

        //Plota informações em Real Time (Canvas)
        public void si_DataReceived(int sem)
        {
            Graphics g, gA;
            Color corLinha = Color.FromArgb(255, 250, 200, 100);
            int minutos, horas, segundos;
            int aceleracaoX, aceleracaoY, aceleracaoZ;
            int posicaoYAceleracaoX, posicaoYAceleracaoY, posicaoYAceleracaoZ;
            double passoX;

            //Seleciona o picture box onde será impresso a informação
            pctboxSelected = pictureBoxRF[selectedPictureBox];

            //Define Passo de Avanço em X
            passoX = (double)pctboxSelected.Width / escalaTempoRF;

            //Define a posição Y onde cada aceleração será impressa
            posicaoYAceleracaoX = 1 * form.pctbxAceleracaoRF.Height/4;
            posicaoYAceleracaoY = 2 * form.pctbxAceleracaoRF.Height / 4;
            posicaoYAceleracaoZ = 3 * form.pctbxAceleracaoRF.Height / 4;

            g = pctboxSelected.CreateGraphics();
            gA = form.pctbxAceleracaoRF.CreateGraphics();
            Pen myPen = new Pen(Color.Black);

            if (semaforo > 0)
            {
                Interlocked.Decrement(ref semaforo);
                sem--;

                for(int i=0;i<4;i++){
                    yCanal1Atual = (1 - (double)((amostrasRF[0, contaAmostraImpressa] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelected.Height / 3;
                    yCanal2Atual = (2 - (double)((amostrasRF[1, contaAmostraImpressa] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelected.Height / 3;
                    yCanal3Atual = (3 - (double)((amostrasRF[2, contaAmostraImpressa] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelected.Height / 3;

                    xAtual = xAtual + passoX; 

                    //Verifica se a impressão não chegou ao final do picture box atual
                    if (xAtual > pctboxSelected.Width)
                    {
                        //Seleciona o próximo picture box
                        if (selectedPictureBox == 3)
                            selectedPictureBox = 0;
                        else
                            selectedPictureBox++;

                        //Seleciona o próximo picture box
                        pctboxSelected = pictureBoxRF[selectedPictureBox];
                        //Posiciona a impressão no começo do picture box
                        xAtual = 0;

                        // apaga os graficos do pictureBox recém-selecionado
                        pctboxSelected.Image = desenhaGrade(pctboxSelected.Width, pctboxSelected.Height, corLinha);
                        pctboxSelected.Refresh();
                    }

                    if (xAtual != 0)
                    {
                        //Desenha gráfico
                        g.DrawLine(myPen, (int)xAnterior, (int)yCanal1Anterior, (int)xAtual, (int)yCanal1Atual);
                        g.DrawLine(myPen, (int)xAnterior, (int)yCanal2Anterior, (int)xAtual, (int)yCanal2Atual);
                        g.DrawLine(myPen, (int)xAnterior, (int)yCanal3Anterior, (int)xAtual, (int)yCanal3Atual);

                        //Imprime a aceleração
                        if (contaAmostraImpressa%16==0)
                        {
                            aceleracaoX = (int)(amostrasAceleracaoRF[0, contaAmostraImpressa] * form.pctbxAceleracaoRF.Width / 4000);
                            aceleracaoY = (int)(amostrasAceleracaoRF[1, contaAmostraImpressa] * form.pctbxAceleracaoRF.Width / 4000);
                            aceleracaoZ = (int)(amostrasAceleracaoRF[2, contaAmostraImpressa] * form.pctbxAceleracaoRF.Width / 4000);
                            //Apaga o picture box
                            form.pctbxAceleracaoRF.Refresh(); 
                            //Desenha os novos valores
                            gA.DrawLine(myPen, 0, posicaoYAceleracaoX, aceleracaoX, posicaoYAceleracaoX);
                            gA.DrawLine(myPen, 0, posicaoYAceleracaoY, aceleracaoY, posicaoYAceleracaoY);
                            gA.DrawLine(myPen, 0, posicaoYAceleracaoZ, aceleracaoZ, posicaoYAceleracaoZ);
                            
                        }
                    }

                    //Armazena os valores atuais
                    xAnterior = xAtual;
                    yCanal1Anterior = yCanal1Atual;
                    yCanal2Anterior = yCanal2Atual;
                    yCanal3Anterior = yCanal3Atual;
                    
                    //Exibi tempo relativo as amostras impressas
                    segundos = tempo / (960);
                    minutos = segundos / 60;
                    horas = minutos / 60;
                    minutos = minutos % 60;
                    segundos = segundos % 60;
                    form.txtbxTempoGravacao.Text = String.Format("{0:D2}:{1:D2}:{2:D2}", horas, minutos, segundos) ;

                    contaAmostraImpressa++;
                    tempo++;
                    if (contaAmostraImpressa > 863999)
                    {
                        contaAmostraImpressa = 0;
                    }

                }
            }
        }

        //Imprime informações em bitmap
        //Obs. Este método imprime de trás para frente, ou seja, do final para o início
        public void rePloteRF()
        {
            if (escalaTempoRF != 0)
            {

                int contaAmostraReplote = contaAmostra;

                Graphics g;
                //Detecta onde esta ocorrendo a impressão atual
                selectedPictureBoxReplote = selectedPictureBox;
                //Seleciona o picture box onde será impresso a informação
                pctboxSelectedReplote = pictureBoxRF[selectedPictureBoxReplote];
                //Define Passo de Recuo em X
                double passoX=(double)pctboxSelectedReplote.Width / escalaTempoRF;

                //Zera parametros
                xAnteriorReplote = 0;
                yCanal1AnteriorReplote = yCanal2AnteriorReplote = yCanal3AnteriorReplote = 0;

                g = Graphics.FromImage(pctboxSelectedReplote.Image);
                Pen myPen = new Pen(Color.Black);

                //Detecta último valor impresso
                xAtualReplote = xAtual;
                yCanal1AtualReplote = yCanal1Atual;
                yCanal2AtualReplote = yCanal2Atual;
                yCanal3AtualReplote = yCanal3Atual;

                for (int i = 0; i < 4; i++) { //Faz para os 4 picture box de RF

                    while(xAtualReplote>0)
                    {
                        contaAmostraReplote--; //Decrementa - de tras para frente
                        if (contaAmostraReplote < 0) {
                            break;
                        }

                        //Seta parametros
                        xAnteriorReplote = xAtualReplote - passoX;
                        yCanal1AnteriorReplote = (1 - (double)((amostrasRF[0, contaAmostraReplote] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelectedReplote.Height / 3;
                        yCanal2AnteriorReplote = (2 - (double)((amostrasRF[1, contaAmostraReplote] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelectedReplote.Height / 3;
                        yCanal3AnteriorReplote = (3 - (double)((amostrasRF[2, contaAmostraReplote] + deslocamentoRF) * ganhoRF) / form.getMAX()) * pctboxSelectedReplote.Height / 3;
                        
                        //Desenha
                        if (xAtualReplote != 0)
                        {
                            g.DrawLine(myPen, (int)xAnteriorReplote, (int)yCanal1AnteriorReplote, (int)xAtualReplote, (int)yCanal1AtualReplote);
                            g.DrawLine(myPen, (int)xAnteriorReplote, (int)yCanal2AnteriorReplote, (int)xAtualReplote, (int)yCanal2AtualReplote);
                            g.DrawLine(myPen, (int)xAnteriorReplote, (int)yCanal3AnteriorReplote, (int)xAtualReplote, (int)yCanal3AtualReplote);
                        }

                        xAtualReplote = xAnteriorReplote;
                        yCanal1AtualReplote = yCanal1AnteriorReplote;
                        yCanal2AtualReplote = yCanal2AnteriorReplote;
                        yCanal3AtualReplote = yCanal3AnteriorReplote;
                    }

                    xAtualReplote = pctboxSelectedReplote.Width;

                    //Seleciona o próximo picture box
                    selectedPictureBoxReplote--;
                    if (selectedPictureBoxReplote < 0)
                        selectedPictureBoxReplote = 3;

                    pctboxSelectedReplote = pictureBoxRF[selectedPictureBoxReplote];
                    g = Graphics.FromImage(pctboxSelectedReplote.Image);
                }

                //Atualiza a imagem dos 4 picture box
                for (int i = 0; i < 4; i++)
                {
                    pictureBoxRF[i].Refresh();
                }
            }
        }

        //Calcula a nova posição para impressão quando existe mudança na escala de tempo
        public void setPosicaoX() {
            if (escalaTempoRF != 0) {
                int numeroQuadros = contaAmostraImpressa / (4 * escalaTempoRF);
                int comecoImpressao = (4 * escalaTempoRF) * numeroQuadros;
                int x = contaAmostraImpressa - comecoImpressao;

                selectedPictureBox = x / escalaTempoRF;
                pctboxSelected = pictureBoxRF[selectedPictureBox];
                xAtual = (x % escalaTempoRF)*((double)pctboxSelected.Width / escalaTempoRF);
                xAnterior = xAtual - (double)pctboxSelectedReplote.Width / escalaTempoRF;
            }
        }

        public void setGanho(double ganhoRF)
        {
            this.ganhoRF = ganhoRF;
            //Corrigi referência
            if(ganhoRF==0.5)
                deslocamentoRF = (int)(819); //0,5V = 819     1,0V = 1639
            else if(ganhoRF==1)
                deslocamentoRF = 0;
            else if (ganhoRF == 2)
                deslocamentoRF = -(int)(819 / 2);
        }

        public void setVelocidade(int escalaTempoRF) {
            this.escalaTempoRF = escalaTempoRF;
            setPosicaoX();
            plotaGradeRF();
            rePloteRF();
        }

        public void pictureBoxRFClick(MouseEventArgs mouseEvent, int pctboxSelectedRF)
        {
            int inicioDetalhe;
            //Obs. É considerado um quadro os quatro picture boxes
            int numeroQuadros = contaAmostraImpressa / (4 * escalaTempoRF);
            int comecoImpressao = (4 * escalaTempoRF) * numeroQuadros;

            Graphics objGrafico;
            //this.pctboxSelectedSD = pctboxSelectedSD;
            this.plotaGradeRF();
            this.rePloteRF();
            Pen p = new Pen(Color.Red, 0);
            p.Width = 2;
            objGrafico = Graphics.FromImage(pictureBoxRF[pctboxSelectedRF].Image);
            objGrafico.DrawEllipse(p, mouseEvent.X - 5, mouseEvent.Y - 5, 10, 10);

            //Localiza o ponto valido mais próximo
            derivacaoSelecionada = (int)(mouseEvent.Y / (pictureBoxRF[pctboxSelectedRF].Height / 3));
            posicaoSelecionada = (int)(mouseEvent.X * escalaTempoRF / pictureBoxRF[pctboxSelectedRF].Width);
            if (pctboxSelectedRF <= selectedPictureBox)
                inicioDetalhe = comecoImpressao + pctboxSelectedRF * escalaTempoRF + posicaoSelecionada - (tamanhoDetalhe / 2);
            else
                inicioDetalhe = comecoImpressao + pctboxSelectedRF * escalaTempoRF + posicaoSelecionada - (tamanhoDetalhe / 2) - escalaTempoRF*4;
            if (inicioDetalhe < 0)
                inicioDetalhe = 0;

            for (int i = inicioDetalhe; i < inicioDetalhe + tamanhoDetalhe; i++)
                amostrasDetalhada[i - inicioDetalhe] = amostrasRF[derivacaoSelecionada, i];

            pictureBoxRF[pctboxSelectedRF].Refresh();
            form.btnFazerMedidasRF.Enabled = true;

        }

        public void salvarArquivo() {
            byte[] zeros = new byte[32];
            if (dlg == null)
                dlg = new SaveFileDialog();
            dlg.Title = "Salvar arquivo com os dados do ECG";
            dlg.Filter = "ecg arquivos (*.ttt)|*.ttt";
            dlg.ShowDialog();

            //Verifica se algum arquivo foi selecionado
            if (dlg.FileName != "")
            {
                //Abre arquivo selecionado
                output = new FileStream(dlg.FileName, FileMode.Create, FileAccess.Write);
                //streamReader = new StreamReader(inputStream);
                br = new BinaryWriter(output);

                if (estourou15minutos) //Caso tenha se passado mais de 15 min
                {
 
                    int referencia = 6 * contaAmostra;
                    for (int i = 0; i < 6 * 864000; i++)
                    {
                        if ((i) % 480 == 0)
                        {
                            br.Write(zeros);
                        }
                        if (i + referencia == 6 * 864000) {
                            referencia = -i;
                        }
                        br.Write(amostra[i + referencia]);
                    }

                }
                else
                {
                    for (int i = 0; i < 6 * contaAmostra; i++)
                    {
                        if (i % 480 == 0)
                        {
                            br.Write(zeros);
                        }
                        br.Write(amostra[i]);
                    }
                }

                br.Close();
                output.Close();
            }
            dlg.Dispose();
        }

        public void interromperCaptura() {
            if (form.btnInterromperCaptura.Text == "Interromper Captura")
            {
                form.cbPorta.Enabled = true;
                form.SP.Close();
                form.timer.Enabled = false;
                form.btnInterromperCaptura.Text = "Continuar Captura";
                semaforo = 0;
            }
            else {
                form.SP.Open();              //Abrir a Porta 
                form.timer.Enabled = true;   // Acionar o posicaoPictureBoxador de Tempo
                form.SP.DiscardInBuffer();
                form.btnInterromperCaptura.Text = "Interromper Captura"; 

            }
        }

    }
}
